1. Crie uma classe que modele um quadrado, com um atributo lado e os métodos: mudar valor do lado, retornar valor do lado e calcular área.
Solução:
In [1]:
class Square(object):
"""
Classe que modela um quadrado.
"""
def __init__(self, side=1):
self.side = side
def get_side(self):
return self.side
def set_side(self, side):
self.side = side
def get_area(self):
# A área é o quadrado do lado
return self.side ** 2
# Testes
square = Square(2)
square.set_side(3)
print square.get_area()
2. Crie uma classe derivada de lista com um método retorne os elementos da lista sem repetição.
Solução:
In [2]:
class List(list):
def unique(self):
"""
Retorna a lista sem repetições.
"""
res = []
for item in self:
if item not in res:
res.append(item)
return res
# Teste
l = List([1, 1, 2, 2, 2, 3, 3])
print l.unique()
3. Implemente uma classe Carro com as seguintes propriedades:
mover(km) que receba a distância em quilômetros e reduza o nível de combustível no tanque de gasolina.gasolina(), que retorna o nível atual de combustível.abastecer(litros), para abastecer o tanque.Solução:
In [3]:
class Carro(object):
"""
Classe que calcula o consumo de um carro.
"""
tanque = 0
def __init__(self, consumo):
self.consumo = consumo
def mover(self, km):
gasto = self.consumo * km
if self.tanque > gasto:
self.tanque = self.tanque - gasto
else:
self.tanque = 0
def abastecer(self, litros):
self.tanque = self.tanque + litros
def gasolina(self):
return self.tanque
# Teste
carro = Carro(consumo=5)
carro.abastecer(litros=220)
carro.mover(km=20)
print carro.gasolina()
4. Implementar uma classe Vetor:
Solução:
In [4]:
import math
class Vetor(object):
def __init__(self, x, y, z):
self.x = float(x)
self.y = float(y)
self.z = float(z)
def __repr__(self):
return 'Vetor(x=%.1f, y=%.1f, z=%.1f)' % (self.x, self.y, self.z)
def __add__(self, v):
x = self.x + v.x
y = self.y + v.y
z = self.z + v.z
return Vetor(x, y, z)
def __sub__(self, v):
x = self.x - v.x
y = self.y - v.y
z = self.z - v.z
return Vetor(x, y, z)
def __abs__(self):
tmp = self.x ** 2 + self.y ** 2 + self.z ** 2
return math.sqrt(tmp)
def __mul__(self, v):
if isinstance(v, Vetor):
x = self.y * v.z - v.y * self.z
y = self.z * v.x - v.z * self.x
z = self.x * v.y - v.x * self.y
else:
x = self.x * float(v)
y = self.y * float(v)
z = self.z * float(v)
return Vetor(x, y, z)
vetor = Vetor(1, 2, 3)
print abs(vetor)
print Vetor(4.5, 5, 6) + vetor
print Vetor(4.5, 5, 6) - vetor
print Vetor(4.5, 5, 6) * vetor
print Vetor(4.5, 5, 6) * 5
5. Implemente um módulo com:
Solução:
In [5]:
class Ponto(object):
def __init__(self, x, y, z):
# Coordenadas
self.x = float(x)
self.y = float(y)
self.z = float(z)
def __repr__(self):
return '(%2.1f, %2.1f, %2.1f)' % \
(self.x, self.y, self.z)
class Linha(object):
def __init__(self, a, b):
# Pontos
self.a = a
self.b = b
def comp(self):
x = self.b.x - self.a.x
y = self.b.y - self.a.y
z = self.b.z - self.a.z
return round((x ** 2 + y ** 2 + z ** 2)\
** .5, 1)
def __repr__(self):
return '%s => %s' % \
(self.a, self.b)
class Triangulo(object):
def __init__(self, a, b, c):
# Vertices
self.a = a
self.b = b
self.c = c
# Lados
self.ab = Linha(a, b)
self.bc = Linha(b, c)
self.ca = Linha(c, a)
def area(self):
# Comprimento dos lados
ab = self.ab.comp()
bc = self.bc.comp()
ca = self.ca.comp()
# Semiperimetro
p = (ab + bc + ca) / 2.
# Teorema de Heron
return round((p * (p - ab) * (p - bc) \
* (p - ca)) ** .5, 1)
def __repr__(self):
return '%s => %s => %s)' % \
(self.a, self.b, self.c)
# Testes
a = Ponto(2, 3, 1)
b = Ponto(5, 1, 4)
c = Ponto(4, 2, 5)
l = Linha(a, b)
t = Triangulo(a, b, c)
print 'Ponto A:', a
print 'Ponto B:', b
print 'Ponto C:', c
print 'Linha:', l
print 'Comprimento:', l.comp()
print 'Triangulo:', t
print 'Area:', t.area()
# Mostra:
# Ponto A: (2.0, 3.0, 1.0)
# Ponto B: (5.0, 1.0, 4.0)
# Ponto C: (4.0, 2.0, 5.0)
# Linha: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0)
# Comprimento: 4.7
# Triangulo: (2.0, 3.0, 1.0) => (5.0, 1.0, 4.0) => (4.0, 2.0, 5.0))
# Area: 3.9
In [1]:
Out[1]: